﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class ONPresupuestoAlarma
    {
        public string FechaHoraString
        {
            get
            {
                return FechaHora.ToString("dd/MM/yyyy");
            }
            set
            {
                DateTime _fh;
                if (DateTime.TryParse(value,out _fh) == false)
                    _fh = DateTime.Parse("01/01/1900");
                FechaHora = _fh;
            }
        }
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class ONPresupuestoAlarma
    {
        #region Atributos
        protected int _id;
        protected DateTime _fechaHora;
        protected string _motivo;
        protected bool _estaActiva;
        protected int _idPresupuesto;        
        
        //Objetos asociados
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public DateTime FechaHora
        {
            get
            {
                return _fechaHora;
            }
            set
            {
                _fechaHora = value;
            }
        }
        public string Motivo
        {
            get
            {
                return _motivo;
            }
            set
            {
                _motivo = value;
            }
        }
        public bool EstaActiva
        {
            get
            {
                return _estaActiva;
            }
            set
            {
                _estaActiva = value;
            }
        }
        public int IdPresupuesto
        {
            get
            {
                return _idPresupuesto;
            }
            set
            {
                _idPresupuesto = value;
            }
        }
        
        //Objetos asociados

        //Propiedades derivadas
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static PresupuestoAlarmaTableAdapter _presupuestoAlarmaAD;
        protected static PresupuestoAlarmaTableAdapter Adaptador
        {
            get
            {
                if (_presupuestoAlarmaAD == null)
                    _presupuestoAlarmaAD = new PresupuestoAlarmaTableAdapter();

                return _presupuestoAlarmaAD;
            }
        }
        protected static ONPresupuestoAlarma ObtenerPorID(int pID)
        {
            ONPresupuestoAlarma _presupuestoAlarma = null;
            _STG_DAL.PresupuestoAlarmaDataTable _dt;

            // obtengo el PresupuestoAlarma por ID
            PresupuestoAlarmaTableAdapter _adaptador = new PresupuestoAlarmaTableAdapter(); // lo creo aca por que este es un metodo estatico
            _dt = _adaptador.ObtenerPorId(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                _presupuestoAlarma = AsignarRowAObjeto((_STG_DAL.PresupuestoAlarmaRow)_dt.Rows[0]);

            return _presupuestoAlarma;
        }
        protected static ONPresupuestoAlarma AsignarRowAObjeto(_STG_DAL.PresupuestoAlarmaRow pRow)
        {
            ONPresupuestoAlarma _presupuestoAlarma = null;
            if (pRow != null)
            {
                _presupuestoAlarma = new ONPresupuestoAlarma();
                _presupuestoAlarma.ID = pRow.ID;
                try { _presupuestoAlarma.FechaHora = pRow.FechaHora; }
                catch { _presupuestoAlarma.FechaHora = DateTime.MinValue; }
                try { _presupuestoAlarma.Motivo = pRow.Motivo; }
                catch { _presupuestoAlarma.Motivo = ""; }
                try { _presupuestoAlarma.EstaActiva = pRow.EstaActiva; }
                catch { _presupuestoAlarma.EstaActiva = true; }
                try { _presupuestoAlarma.IdPresupuesto = pRow.IdPresupuesto; }
                catch { _presupuestoAlarma.IdPresupuesto = 0; }
            }
            return _presupuestoAlarma;
        }
        protected ONPresupuestoAlarma InsertarDAL(DateTime pFechaHora,string pMotivo,bool pEstaActiva,int pIdPresupuesto)
        {
            ID = int.Parse(Adaptador.Insertar(pFechaHora, pMotivo, pEstaActiva, pIdPresupuesto).ToString());
            return this;
        }
        protected bool EliminarDAL(int pID)
        {
            if (Adaptador.Eliminar(pID) == 0)
                return false;
            else
                return true;
        }
        public static bool EliminarPorPresupuesto(int pIdPresupuesto)
        {
            Adaptador.EliminarPorPresupuesto(pIdPresupuesto);
            return true;
        }
        protected bool ActualizarDAL(DateTime pFechaHora,string pMotivo,bool pEstaActiva,int pIdPresupuesto, int pId)
        {
            if (0 < Adaptador.Actualizar(pFechaHora, pMotivo, pEstaActiva, pIdPresupuesto, pId))
                return true;
            else
                return false;
        }
        public static ONPresupuestoAlarmaColeccion ObtenerAlarmasDePresupuestoDAL(int pIDPresupuesto)
        {
            _STG_DAL.PresupuestoAlarmaDataTable _dt;

            PresupuestoAlarmaTableAdapter _adaptador = new PresupuestoAlarmaTableAdapter(); // lo creo aca por que este es un metodo estatico
            _dt = _adaptador.ObtenerAlarmasDePresupuesto(pIDPresupuesto);

            return AsignarPresupuestoAlarmaTableAdapterAPresupuestoAlarmaColeccion(_dt);

        }
        protected static ONPresupuestoAlarmaColeccion AsignarPresupuestoAlarmaTableAdapterAPresupuestoAlarmaColeccion(_STG_DAL.PresupuestoAlarmaDataTable pDataTable)
        {
            ONPresupuestoAlarmaColeccion _presupuestoAlarmas = new ONPresupuestoAlarmaColeccion();
            ONPresupuestoAlarma _presupuestoAlarma;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.PresupuestoAlarmaRow _row in pDataTable.Rows)
                {
                    _presupuestoAlarma = AsignarRowAObjeto(_row);
                    if (_presupuestoAlarma != null)
                        _presupuestoAlarmas.Add(_presupuestoAlarma);
                }
            }
            return _presupuestoAlarmas;
        }

        #endregion

        #region Métodos
        public ONPresupuestoAlarma()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            FechaHora = DateTime.Parse("01/01/1900");
            Motivo = "";
            EstaActiva = true;
            IdPresupuesto = -1;
        }

        public static ONPresupuestoAlarma CrearPresupuestoAlarma()
        {
            ONPresupuestoAlarma _presupuestoAlarma = new ONPresupuestoAlarma();
            return _presupuestoAlarma;
        }
        public static ONPresupuestoAlarma CrearPresupuestoAlarma(int pID)
        {
            ONPresupuestoAlarma _presupuestoAlarma = ObtenerPorID(pID);
            return _presupuestoAlarma;
        }
        public ONPresupuestoAlarma Insertar()
        {
            return InsertarDAL(FechaHora, Motivo, EstaActiva, IdPresupuesto);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(FechaHora, Motivo, EstaActiva, IdPresupuesto, ID);
        }
        /// <summary>
        /// Elimina todos los elemntos asociados al presupuesto.
        /// </summary>
        /// <param name="pIdPresupuesto"></param>
        /// <returns></returns>
        public bool Eliminar(int pIdPresupuesto)
        {
            return this.EliminarDAL(pIdPresupuesto);
        }
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            if (pPresupuestoAlarma != null)
                pPresupuestoAlarma.Actualizar();
        }
        public ONPresupuestoAlarma Insertar(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            if (pPresupuestoAlarma != null)
                return pPresupuestoAlarma.Insertar();
            return null;
        }
        /// <summary>
        /// Elimina todos los PresupuestoAlarmas que esten asociados al mismo presupuesto.
        /// </summary>
        /// <param name="pPresupuestoAlarma"></param>
        public void Eliminar(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            pPresupuestoAlarma.Eliminar(pPresupuestoAlarma.ID);
            pPresupuestoAlarma = null;
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class ONPresupuestoAlarmaColeccion : System.Collections.CollectionBase
    {
        public void Add(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            this.List.Add(pPresupuestoAlarma);
        }
        public void AddUnico(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            foreach (ONPresupuestoAlarma _presupuestoAlarma in this)
                if (pPresupuestoAlarma.ID == _presupuestoAlarma.ID)
                    return;
            this.List.Add(pPresupuestoAlarma);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pPresupuestoAlarma.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public ONPresupuestoAlarma this[int index]
        {
            get { return ((ONPresupuestoAlarma)(this.List[index])); }
            set { this.List[index] = value; }
        }
        public void ActualizarPresupuestoAlarmas(ONPresupuestoAlarmaColeccion pPresupuestoAlarmas)
        {
            foreach (ONPresupuestoAlarma _presupuestoAlarma in pPresupuestoAlarmas)
            {
                _presupuestoAlarma.Actualizar();
            }
        }
        public void ActualizarPresupuestoAlarma(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            pPresupuestoAlarma.Actualizar();
        }

        #region Metodos de colección
        
        #endregion
        #region Para datasource
        public void Eliminar(ONPresupuestoAlarma pPresupuestoAlarma)
        {   
            pPresupuestoAlarma.Eliminar(pPresupuestoAlarma.ID);
        }
        public void Insertar(ONPresupuestoAlarma pPresupuestoAlarma)
        {
            pPresupuestoAlarma.Insertar(pPresupuestoAlarma);
        }
        /// <summary>
        /// Devuelve todas las alarmas del presupuesto.
        /// </summary>
        /// <returns></returns>        
        public static ONPresupuestoAlarmaColeccion ObtenerAlarmasDePresupuesto(int pIdPresupuesto)
        {
            return ONPresupuestoAlarma.ObtenerAlarmasDePresupuestoDAL(pIdPresupuesto);            
        }
        /// <summary>
        /// Obtiene las alarmas activas de la colección dada
        /// </summary>
        /// <returns></returns>
        public ONPresupuestoAlarmaColeccion ObtenerAlarmasActivas()
        {
            ONPresupuestoAlarmaColeccion _resultado = new ONPresupuestoAlarmaColeccion();

            foreach (ONPresupuestoAlarma _alarma in this)
                if (_alarma.EstaActiva == true)
                    _resultado.Add(_alarma);

            return _resultado;
        }
        /// <summary>
        /// Devuelve la proxima alarma activa
        /// </summary>
        public ONPresupuestoAlarma ObtenerProximaAlarma
        {
            get
            {
                ONPresupuestoAlarmaColeccion _alarmasActivas = ObtenerAlarmasActivas();
                ONPresupuestoAlarma _resultado = new ONPresupuestoAlarma();
                _resultado.FechaHora = DateTime.Today.AddYears(10);

                foreach (ONPresupuestoAlarma _alarmaDeColeccion in _alarmasActivas)
                {
                    if ((_alarmaDeColeccion.FechaHora >= DateTime.Today)
                        && (_alarmaDeColeccion.FechaHora <= _resultado.FechaHora))
                        _resultado = _alarmaDeColeccion;
                }
                if (_resultado.ID == -1)
                    _resultado = null;
                return _resultado;
            }
        }
        public DateTime? FechaHoraProximaAlarma
        {
            get
            {
                ONPresupuestoAlarma _proximaAlarma = ObtenerProximaAlarma;
                if (_proximaAlarma == null)
                    return null;
                else
                    return _proximaAlarma.FechaHora;
            }
        }
        public string ProximaAlarmaMotivo
        {
            get{
                ONPresupuestoAlarma _proximaAlarma = ObtenerProximaAlarma;
                if (_proximaAlarma == null)
                    return "";
                else
                    return _proximaAlarma.Motivo;
            }
        }
        #endregion
    }
}
